#pragma once

#include "task_base.h"
#include "application/vehicle/vehicle_service.h"
#include "application/dispatcher/dispatcher_service.h"
#include "application/map/map_application_service.h"
#include <chrono>
#include <QList>
#include <memory>
#include <string>

namespace application {
namespace area { class Area; }
namespace task {

/**
 * @brief 移动任务 - AGV导航到目标站点
 * @details 对应三方代码中的 TaskMove
 *          通过调度系统选择AGV并下发移动任务
 */
class MoveTask : public SubTaskBase {
public:
    /**
     * @brief 构造函数
     * @param targetStation 目标站点ID
     * @param floor 楼层
     * @param vehicleService 车辆服务
     * @param dispatcherService 调度服务
     * @param logger 日志记录器
     * @param operation 到达站点后的操作（可选，用于MKLM的finalOperation）
     */
    MoveTask(
        const std::string& targetStation,
        int floor,
        std::shared_ptr<vehicle::VehicleService> vehicleService,
        std::shared_ptr<dispatcher::DispatcherService> dispatcherService,
        std::shared_ptr<MapApplicationService> mapService,
        std::shared_ptr<kernel::ILogger> logger,
        const std::string& operation = ""
    );

    ~MoveTask() override = default;

    // SubTaskBase 接口实现
    kernel::task::TaskStage init(TaskContext& ctx) override;
    kernel::task::TaskStage run(TaskContext& ctx) override;
    kernel::task::TaskStage cleanup(TaskContext& ctx) override;

    kernel::task::TaskType getType() const override {
        return kernel::task::TaskType::Move;
    }

    std::string getDescription() const override {
        return "Move to station: " + m_targetStation;
    }

    const std::string& getTargetStation() const {
        return m_targetStation;
    }

    int getFloor() const {
        return m_floor;
    }

    /**
     * @brief 调度器分段下发事件回调
     * @param segment 调度路径段
     */
    void notifyDispatch(const QList<QString>& segment);

private:
    // 目标站点
    std::string m_targetStation;

    // 楼层
    int m_floor;

    // 车辆服务
    std::shared_ptr<vehicle::VehicleService> m_vehicleService;

    // 调度服务
    std::shared_ptr<dispatcher::DispatcherService> m_dispatcherService;

    // 地图服务
    std::shared_ptr<MapApplicationService> m_mapService;

    // 到达站点后的操作（可选）
    std::string m_operation;

    // 任务是否已下发
    bool m_taskIssued{false};
    bool m_waitingForDispatch{false};

    // 是否已占用目标区域
    bool m_areaOccupied{false};
    int m_occupyingAgvNumber{-1};
    std::string m_lastStation;
    std::chrono::steady_clock::time_point m_lastProgressTime{};
    bool m_timeoutNotified{false};
    kernel::agv::NavStatus m_lastNavStatus{kernel::agv::NavStatus::None};

    static constexpr int DEFAULT_SUSPEND_TICKS = 30;
    static constexpr int NAVIGATION_PROGRESS_TIMEOUT_SEC = 60;

    /**
     * @brief 检查AGV是否到达目标站点
     * @param ctx 任务上下文
     * @return 是否到达
     */
    bool hasArrived(const TaskContext& ctx) const;

    /**
     * @brief 检查导航任务是否完成
     * @param ctx 任务上下文
     * @return 是否完成
     */
    bool isNavigationComplete(const TaskContext& ctx) const;

    /**
     * @brief 检查是否需要跨楼层执行
     */
    bool checkCrossFloor(TaskContext& ctx) const;

    /**
     * @brief 检测并占用目标区域
     */
    bool acquireTargetArea(TaskContext& ctx);

    /**
     * @brief 获取目标区域（若存在）
     */
    std::shared_ptr<area::Area> getTargetArea() const;

    void releaseOccupiedResources(TaskContext& ctx);
    void enterTimeoutState(TaskContext& ctx, const std::string& message);
    void clearTimeoutState(TaskContext& ctx);
    void resetNavigationRequest();
};

} // namespace task
} // namespace application
